Files
keepassxc/tests/TestImports.cpp
T
Janek Bevendorff a276a44b9a Bound allocation size in OpData01 reader
Thanks @smaeljaish771 for reporting
2026-11-05 08:15:26 +01:00

595 lines
25 KiB
C++

/*
* Copyright (C) 2026 KeePassXC Team <[email protected]>
*
* 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 "TestImports.h"
#include "config-keepassx-tests.h"
#include "core/Group.h"
#include "core/Metadata.h"
#include "core/Totp.h"
#include "crypto/Crypto.h"
#include "crypto/CryptoHash.h"
#include "crypto/SymmetricCipher.h"
#include "format/BitwardenReader.h"
#include "format/OPUXReader.h"
#include "format/OpData01.h"
#include "format/OpVaultReader.h"
#include "format/ProtonPassReader.h"
#include <QJsonObject>
#include <QList>
#include <QTest>
#include <QtEndian>
#include <limits>
QTEST_GUILESS_MAIN(TestImports)
void TestImports::initTestCase()
{
QVERIFY(Crypto::init());
QLocale::setDefault(QLocale::c());
}
namespace
{
QByteArray makeOpData01(quint64 plaintextLen, const QByteArray& ciphertext)
{
QByteArray frame("opdata01");
char length[sizeof(quint64)];
qToLittleEndian(plaintextLen, length);
frame.append(length, sizeof(length));
frame.append(QByteArray(16, 'i'));
frame.append(ciphertext);
frame.append(CryptoHash::hmac(frame, QByteArray(32, 'm'), CryptoHash::Sha256));
return frame;
}
} // namespace
void TestImports::testOpData01_data()
{
QTest::addColumn<int>("plaintextLen");
QTest::newRow("empty") << 0;
QTest::newRow("one-byte") << 1;
QTest::newRow("one-padding-byte") << 15;
QTest::newRow("full-padding-block") << 16;
QTest::newRow("two-blocks") << 17;
QTest::newRow("two-blocks-one-padding-byte") << 31;
QTest::newRow("two-full-blocks") << 32;
QTest::newRow("master-key-size") << 256;
}
void TestImports::testOpData01()
{
QFETCH(int, plaintextLen);
const QByteArray plaintext(plaintextLen, 'x');
QByteArray ciphertext(16 - plaintextLen % 16, 'p');
ciphertext.append(plaintext);
const QByteArray key(32, 'k');
const QByteArray hmacKey(32, 'm');
SymmetricCipher cipher;
QVERIFY(cipher.init(SymmetricCipher::Aes256_CBC, SymmetricCipher::Encrypt, key, QByteArray(16, 'i')));
QVERIFY(cipher.process(ciphertext));
const auto frame = makeOpData01(plaintextLen, ciphertext);
OpData01 decoder;
QVERIFY2(decoder.decode(frame, key, hmacKey), qPrintable(decoder.errorString()));
QCOMPARE(decoder.getClearText(), plaintext);
QVERIFY2(decoder.decodeBase64(QString::fromLatin1(frame.toBase64()), key, hmacKey),
qPrintable(decoder.errorString()));
QCOMPARE(decoder.getClearText(), plaintext);
}
void TestImports::testOpData01Invalid_data()
{
QTest::addColumn<QByteArray>("frame");
QTest::addColumn<QString>("error");
const QString lengthError = QStringLiteral("Plain text length out of range");
const QByteArray ciphertext(32, 'c');
// Authenticate malformed frames so that HMAC failure cannot mask missing length validation.
QTest::newRow("no-padding") << makeOpData01(32, ciphertext) << lengthError;
QTest::newRow("plaintext-exceeds-ciphertext") << makeOpData01(33, ciphertext) << lengthError;
QTest::newRow("excess-padding") << makeOpData01(15, ciphertext) << lengthError;
QTest::newRow("huge-length") << makeOpData01(static_cast<quint64>(1) << 36, ciphertext) << lengthError;
QTest::newRow("length-exceeds-32-bits")
<< makeOpData01((static_cast<quint64>(1) << 32) + 16, ciphertext) << lengthError;
QTest::newRow("high-bit-set") << makeOpData01((static_cast<quint64>(1) << 63) + 16, ciphertext) << lengthError;
QTest::newRow("maximum-length") << makeOpData01(std::numeric_limits<quint64>::max(), ciphertext) << lengthError;
QTest::newRow("missing-ciphertext") << makeOpData01(0, {}) << QStringLiteral("Invalid OpData01 data length");
QTest::newRow("unaligned-ciphertext")
<< makeOpData01(16, QByteArray(17, 'c')) << QStringLiteral("Invalid OpData01 ciphertext length");
const auto validFrame = makeOpData01(16, ciphertext);
for (int offset : {8, 16, 32, 64}) {
auto frame = validFrame;
frame[offset] ^= 1; // Alter the length, IV, ciphertext, or HMAC without updating the signature.
QTest::newRow(qPrintable(QStringLiteral("tampered-byte-%1").arg(offset)))
<< frame << QStringLiteral("failed HMAC");
}
}
void TestImports::testOpData01Invalid()
{
QFETCH(QByteArray, frame);
QFETCH(QString, error);
OpData01 decoder;
// An invalid encryption key also ensures malformed data is rejected before cipher initialization.
QVERIFY(!decoder.decode(frame, {}, QByteArray(32, 'm')));
QVERIFY2(decoder.errorString().contains(error), qPrintable(decoder.errorString()));
QVERIFY(decoder.getClearText().isEmpty());
}
void TestImports::testOpData01Truncated()
{
const auto frame = makeOpData01(16, QByteArray(32, 'c'));
for (qsizetype size = 0; size < frame.size(); ++size) {
OpData01 decoder;
QVERIFY2(!decoder.decode(frame.left(size), QByteArray(32, 'k'), QByteArray(32, 'm')),
qPrintable(QStringLiteral("Accepted frame truncated to %1 bytes").arg(size)));
}
}
void TestImports::testOPUX()
{
auto opuxPath = QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/1PasswordExport.1pux"));
OPUXReader reader;
auto db = reader.convert(opuxPath);
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
// Confirm specific entry details are valid
auto entry = db->rootGroup()->findEntryByPath("/Personal/Login");
QVERIFY(entry);
QCOMPARE(entry->title(), QStringLiteral("Login"));
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->password(), QStringLiteral("password"));
QCOMPARE(entry->url(), QStringLiteral("https://keepassxc.org"));
QCOMPARE(entry->notes(), QStringLiteral("Note to self"));
// Check extra URL's
QCOMPARE(entry->attribute("KP2A_URL_1"), QStringLiteral("https://twitter.com"));
// Check TOTP
QVERIFY(entry->hasTotp());
QVERIFY(!entry->attribute("otp_1").isEmpty());
// Check tags
QVERIFY(entry->tagList().contains("Favorite"));
QVERIFY(entry->tagList().contains("website"));
// Check attachments
entry = db->rootGroup()->findEntryByPath("/Personal/KeePassXC Logo");
auto attachments = entry->attachments();
QCOMPARE(attachments->keys().count(), 1);
QCOMPARE(attachments->keys()[0], QString("keepassxc.png"));
// Confirm advanced attributes
// NOTE: 1PUX does not support an explicit expiration field
entry = db->rootGroup()->findEntryByPath("/Personal/Credit Card");
QVERIFY(entry);
auto tmpl = QString("Credit Card Fields_%1");
auto attr = entry->attributes();
QCOMPARE(attr->value(tmpl.arg("cardholder name")), QStringLiteral("KeePassXC"));
QCOMPARE(attr->value(tmpl.arg("expiry date")), QStringLiteral("202206"));
QCOMPARE(attr->value(tmpl.arg("verification number")), QStringLiteral("123"));
QVERIFY(attr->isProtected(tmpl.arg("verification number")));
// Confirm address fields
entry = db->rootGroup()->findEntryByPath("/Personal/Identity");
QVERIFY(entry);
attr = entry->attributes();
QCOMPARE(attr->value("Address_address"), QStringLiteral("123 Avenue Rd\nBoston, MA 12345\nus"));
// Check archived entries
entry = db->rootGroup()->findEntryByPath("/Personal/Login Archived");
QVERIFY(entry);
QVERIFY(entry->tagList().contains("Archived"));
// Check vault to group structure
entry = db->rootGroup()->findEntryByPath("/Shared/Bank Account");
QVERIFY(entry);
// Check custom group icon
QVERIFY(!entry->group()->iconUuid().isNull());
// Check Category UUID 05 Passwords
entry = db->rootGroup()->findEntryByPath("/Personal/UUID 005 Password");
QVERIFY(entry);
QCOMPARE(entry->password(), QStringLiteral("uuid005password"));
}
void TestImports::testOPVault()
{
auto opVaultPath = QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/keepassxc.opvault"));
auto categories = QStringList({QStringLiteral("Login"),
QStringLiteral("Credit Card"),
QStringLiteral("Secure Note"),
QStringLiteral("Identity"),
QStringLiteral("Password"),
QStringLiteral("Tombstone"),
QStringLiteral("Software License"),
QStringLiteral("Bank Account"),
QStringLiteral("Database"),
QStringLiteral("Driver License"),
QStringLiteral("Outdoor License"),
QStringLiteral("Membership"),
QStringLiteral("Passport"),
QStringLiteral("Rewards"),
QStringLiteral("SSN"),
QStringLiteral("Router"),
QStringLiteral("Server"),
QStringLiteral("Email")});
QDir opVaultDir(opVaultPath);
OpVaultReader reader;
auto db = reader.convert(opVaultDir, "a");
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
// Confirm specific entry details are valid
auto entry = db->rootGroup()->findEntryByPath("/Login/KeePassXC");
QVERIFY(entry);
QCOMPARE(entry->title(), QStringLiteral("KeePassXC"));
QCOMPARE(entry->username(), QStringLiteral("keepassxc"));
QCOMPARE(entry->password(), QStringLiteral("opvault"));
QCOMPARE(entry->url(), QStringLiteral("https://www.keepassxc.org"));
QCOMPARE(entry->notes(), QStringLiteral("KeePassXC Account"));
// Check extra URL's
QCOMPARE(entry->attribute("KP2A_URL_1"), QStringLiteral("https://snapshot.keepassxc.org"));
// Check TOTP
QVERIFY(entry->hasTotp());
// Check attachments
auto attachments = entry->attachments();
QCOMPARE(attachments->keys().count(), 1);
QCOMPARE(*attachments->values().begin(), QByteArray("attachment"));
// Confirm expired entries
entry = db->rootGroup()->findEntryByPath("/Login/Expired Login");
QVERIFY(entry->isExpired());
// Confirm advanced attributes
entry = db->rootGroup()->findEntryByPath("/Credit Card/My Credit Card");
QVERIFY(entry);
auto attr = entry->attributes();
QCOMPARE(attr->value("cardholder name"), QStringLiteral("Team KeePassXC"));
QVERIFY(!attr->value("valid from").isEmpty());
QCOMPARE(attr->value("Additional Details_PIN"), QStringLiteral("1234"));
QVERIFY(attr->isProtected("Additional Details_PIN"));
// Confirm address fields
entry = db->rootGroup()->findEntryByPath("/Identity/Team KeePassXC");
QVERIFY(entry);
attr = entry->attributes();
QCOMPARE(attr->value("address_street"), QStringLiteral("123 Password Lane"));
// Confirm complex passwords
entry = db->rootGroup()->findEntryByPath("/Password/Complex Password");
QVERIFY(entry);
QCOMPARE(entry->password(), QStringLiteral("HfgcHjEL}iO}^3N!?*cv~O:9GJZQ0>oC"));
QVERIFY(entry->hasTotp());
auto totpSettings = entry->totpSettings();
QCOMPARE(totpSettings->digits, static_cast<unsigned int>(8));
QCOMPARE(totpSettings->step, static_cast<unsigned int>(45));
// Add another OTP to this entry to confirm it doesn't overwrite the existing one
auto field = QJsonObject::fromVariantMap({{"n", "TOTP_SETTINGS"}, {"v", "otpauth://test.url?digits=6"}});
reader.fillFromSectionField(entry, "", field);
QVERIFY(entry->hasTotp());
totpSettings = entry->totpSettings();
QCOMPARE(totpSettings->digits, static_cast<unsigned int>(8));
QCOMPARE(totpSettings->step, static_cast<unsigned int>(45));
QVERIFY(entry->attributes()->contains("otp_1"));
// Confirm trashed entries are sent to the recycle bin
auto recycleBin = db->metadata()->recycleBin();
QVERIFY(recycleBin);
QVERIFY(!recycleBin->isEmpty());
QVERIFY(recycleBin->findEntryByPath("Trashed Password"));
// Confirm created groups align with category names
for (const auto group : db->rootGroup()->children()) {
if (group == recycleBin) {
continue;
}
QVERIFY2(categories.contains(group->name()),
qPrintable(QStringLiteral("Invalid group name: %1").arg(group->name())));
// Confirm each group is not empty
QVERIFY2(!group->isEmpty(), qPrintable(QStringLiteral("Group %1 is empty").arg(group->name())));
}
}
void TestImports::testBitwarden()
{
auto bitwardenPath = QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/bitwarden_export.json"));
BitwardenReader reader;
auto db = reader.convert(bitwardenPath);
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
// Confirm Login fields
auto entry = db->rootGroup()->findEntryByPath("/My Folder/Login Name");
QVERIFY(entry);
QCOMPARE(entry->title(), QStringLiteral("Login Name"));
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->password(), QStringLiteral("mypassword"));
QCOMPARE(entry->url(), QStringLiteral("https://mail.google.com"));
QCOMPARE(entry->notes(), QStringLiteral("1st line of note text\n2nd Line of note text"));
// Check extra URL's
QCOMPARE(entry->attribute("KP2A_URL_1"), QStringLiteral("https://google.com"));
QCOMPARE(entry->attribute("KP2A_URL_2"), QStringLiteral("https://gmail.com"));
// Check TOTP
QVERIFY(entry->hasTotp());
// Check Modified and Created timestamps
QCOMPARE(entry->timeInfo().lastModificationTime(),
QDateTime::fromString(QStringLiteral("2024-12-25T12:00:00Z"), Qt::ISODate));
QCOMPARE(entry->timeInfo().creationTime(),
QDateTime::fromString(QStringLiteral("2024-12-01T12:00:00Z"), Qt::ISODate));
// Check Password History
QCOMPARE(entry->historyItems().size(), 1);
QCOMPARE(entry->historyItems().first()->password(), QStringLiteral("oldpassword"));
QCOMPARE(entry->historyItems().first()->timeInfo().lastModificationTime(),
QDateTime::fromString(QStringLiteral("2024-12-01T12:00:00Z"), Qt::ISODate));
// NOTE: Bitwarden does not export attachments
// NOTE: Bitwarden does not export expiration dates
// Confirm Identity fields
entry = db->rootGroup()->findEntryByPath("/My Folder/My Identity");
QVERIFY(entry);
auto attr = entry->attributes();
// NOTE: The extra spaces are deliberate to test unmodified ingest of data
QCOMPARE(attr->value("identity_address"),
QStringLiteral(" 1 North Calle Cesar Chavez \nSanta Barbara, CA 93103\nUnited States "));
QCOMPARE(attr->value("identity_name"), QStringLiteral("Mrs Jane A Doe"));
QCOMPARE(attr->value("identity_ssn"), QStringLiteral("123-12-1234"));
QVERIFY(attr->isProtected("identity_ssn"));
// Confirm Secure Note
entry = db->rootGroup()->findEntryByPath("/My Folder/My Secure Note");
QVERIFY(entry);
QCOMPARE(entry->notes(),
QStringLiteral("1st line of secure note\n2nd line of secure note\n3rd line of secure note"));
// Confirm Credit Card
entry = db->rootGroup()->findEntryByPath("/Second Folder/Card Name");
QVERIFY(entry);
attr = entry->attributes();
QCOMPARE(attr->value("card_cardholderName"), QStringLiteral("Jane Doe"));
QCOMPARE(attr->value("card_number"), QStringLiteral("1234567891011121"));
QCOMPARE(attr->value("card_code"), QStringLiteral("123"));
QVERIFY(attr->isProtected("card_code"));
}
void TestImports::testBitwardenEncrypted()
{
// We already tested the parser so just test that decryption works properly
// First test PBKDF2 password stretching (KDF Type 0)
auto bitwardenPath =
QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/bitwarden_encrypted_export.json"));
BitwardenReader reader;
auto db = reader.convert(bitwardenPath, "a");
if (reader.hasError()) {
QFAIL(qPrintable(reader.errorString()));
}
QVERIFY(db);
// Now test Argon2id password stretching (KDF Type 1)
bitwardenPath = QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR,
QStringLiteral("/bitwarden_encrypted_argon2id_export.json"));
db = reader.convert(bitwardenPath, "a");
if (reader.hasError()) {
QFAIL(qPrintable(reader.errorString()));
}
QVERIFY(db);
}
void TestImports::testBitwardenPasskey()
{
auto bitwardenPath =
QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/bitwarden_passkey_export.json"));
BitwardenReader reader;
auto db = reader.convert(bitwardenPath);
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
// Confirm Login fields
auto entry = db->rootGroup()->findEntryByPath("/webauthn.io");
QVERIFY(entry);
QCOMPARE(entry->title(), QStringLiteral("webauthn.io"));
QCOMPARE(entry->username(), QStringLiteral("KPXC_BITWARDEN"));
QCOMPARE(entry->url(), QStringLiteral("https://webauthn.io/"));
// Confirm passkey attributes
auto attr = entry->attributes();
QCOMPARE(attr->value(EntryAttributes::KPEX_PASSKEY_CREDENTIAL_ID), QStringLiteral("o-FfiyfBQq6Qz6YVrYeFTw"));
QCOMPARE(
attr->value(EntryAttributes::KPEX_PASSKEY_PRIVATE_KEY_PEM),
QStringLiteral(
"-----BEGIN PRIVATE "
"KEY-----"
"MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgmr4GQQjerojFuf0ZouOuUllMvAwxZSZAfB6gwDYcLiehRANCAAT0WR5zVS"
"p6ieusvjkLkzaGc7fjGBmwpiuLPxR/d+ZjqMI9L2DKh+takp6wGt2x0n4jzr1KA352NZg0vjZX9CHh-----END PRIVATE KEY-----"));
QCOMPARE(attr->value(EntryAttributes::KPEX_PASSKEY_USERNAME), QStringLiteral("KPXC_BITWARDEN"));
QCOMPARE(attr->value(EntryAttributes::KPEX_PASSKEY_RELYING_PARTY), QStringLiteral("webauthn.io"));
QCOMPARE(attr->value(EntryAttributes::KPEX_PASSKEY_USER_HANDLE),
QStringLiteral("aTFtdmFnOHYtS2dxVEJ0by1rSFpLWGg0enlTVC1iUVJReDZ5czJXa3c2aw"));
}
void TestImports::testBitwardenNestedFolders()
{
auto bitwardenPath =
QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/bitwarden_nested_export.json"));
BitwardenReader reader;
auto db = reader.convert(bitwardenPath);
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
/* The group tree should be:
/
- Example
- Test Authentication
/SecondTest
- GMail entry
/Test
- Gmail test 2
/Subfolder
- Webauthn.io test 2
/Subfolder
- Test Account
/SubFolder
- WebAuthn.io test
/AnotherSubFolder
- Another test account
- Webauthn.io test 3
*/
// Verify groups
auto secondTestGroup = db->rootGroup()->findGroupByPath("/SecondTest");
QVERIFY(secondTestGroup);
auto testGroup = db->rootGroup()->findGroupByPath("/Test");
QVERIFY(testGroup);
auto testSubfolderLowercaseGroup = db->rootGroup()->findGroupByPath("/Test/Subfolder");
QVERIFY(testSubfolderLowercaseGroup);
auto testSubFolderGroup = db->rootGroup()->findGroupByPath("/Test/SubFolder");
QVERIFY(testSubFolderGroup);
auto longGroup = db->rootGroup()->findGroupByPath("/Test/SubFolder/AnotherSubFolder");
QVERIFY(longGroup);
// Verify entries and the groups they belong to
// GMail entry
auto entry = db->rootGroup()->findEntryByPath("/SecondTest/GMail entry");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->group(), secondTestGroup);
// Test Authentication
entry = db->rootGroup()->findEntryByPath("/Test Authentication");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->group(), db->rootGroup());
// Gmail test 2
entry = db->rootGroup()->findEntryByPath("/Test/Gmail test 2");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->group(), testGroup);
// Example
entry = db->rootGroup()->findEntryByPath("/Example");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("[email protected]"));
QCOMPARE(entry->group(), db->rootGroup());
// WebAuthn.io test
entry = db->rootGroup()->findEntryByPath("/Test/SubFolder/WebAuthn.io test");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("testUser"));
QCOMPARE(entry->group(), testSubFolderGroup);
// Webauthn.io test 2
entry = db->rootGroup()->findEntryByPath("/Test/Subfolder/Webauthn.io test 2");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("testUser2"));
QCOMPARE(entry->group(), testSubfolderLowercaseGroup);
// Webauthn.io test 3
entry = db->rootGroup()->findEntryByPath("/Test/SubFolder/AnotherSubFolder/Webauthn.io test 3");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("testUser3"));
QCOMPARE(entry->group(), longGroup);
// Test Account
// There are two groups with an identical name. The group for this entry should not be the same group with the
// Webauthn.io test 2, but we cannot distinguish these.
entry = db->rootGroup()->findEntryByPath("/Test/Subfolder/Test Account");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("test-account"));
QCOMPARE(entry->group(), testSubfolderLowercaseGroup);
// Another test account
entry = db->rootGroup()->findEntryByPath("/Test/SubFolder/AnotherSubFolder/Another test account");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("anotherUser"));
QCOMPARE(entry->group(), longGroup);
}
void TestImports::testProtonPass()
{
auto protonPassPath =
QStringLiteral("%1/%2").arg(KEEPASSX_TEST_DATA_DIR, QStringLiteral("/protonpass_export.json"));
ProtonPassReader reader;
auto db = reader.convert(protonPassPath);
QVERIFY2(!reader.hasError(), qPrintable(reader.errorString()));
QVERIFY(db);
// Confirm Login fields
auto entry = db->rootGroup()->findEntryByPath("/Personal/Test Login");
QVERIFY(entry);
QCOMPARE(entry->title(), QStringLiteral("Test Login"));
QCOMPARE(entry->username(), QStringLiteral("Username"));
QCOMPARE(entry->password(), QStringLiteral("Password"));
QCOMPARE(entry->url(), QStringLiteral("https://example.com/"));
QCOMPARE(entry->notes(), QStringLiteral("My login secure note."));
// Check extra URL's
QCOMPARE(entry->attribute("KP2A_URL_1"), QStringLiteral("https://example2.com/"));
// Check TOTP
QVERIFY(entry->hasTotp());
// Check attributes
auto attr = entry->attributes();
QVERIFY(attr->isProtected("hidden field"));
QCOMPARE(attr->value("second 2fa secret"), QStringLiteral("TOTPCODE"));
// NOTE: Proton Pass does not export attachments
// NOTE: Proton Pass does not export expiration dates
// Confirm Secure Note
entry = db->rootGroup()->findEntryByPath("/Personal/My Secure Note");
QVERIFY(entry);
QCOMPARE(entry->notes(), QStringLiteral("Secure note contents."));
// Confirm Credit Card
entry = db->rootGroup()->findEntryByPath("/Personal/Test Card");
QVERIFY(entry);
QCOMPARE(entry->username(), QStringLiteral("1234222233334444"));
QCOMPARE(entry->password(), QStringLiteral("333"));
attr = entry->attributes();
QCOMPARE(attr->value("card_cardholderName"), QStringLiteral("Test name"));
QCOMPARE(attr->value("card_expirationDate"), QStringLiteral("2025-01"));
QCOMPARE(attr->value("card_pin"), QStringLiteral("1234"));
QVERIFY(attr->isProtected("card_pin"));
// Confirm Expired (deleted) entry
entry = db->rootGroup()->findEntryByPath("/Personal/My Deleted Note");
QVERIFY(entry);
QTRY_VERIFY(entry->isExpired());
// Confirm second group (vault)
entry = db->rootGroup()->findEntryByPath("/Test/Other vault login");
QVERIFY(entry);
// Confirm unknown type entry
entry = db->rootGroup()->findEntryByPath("/Personal/Unknown Type");
QVERIFY(entry);
attr = entry->attributes();
QCOMPARE(attr->value("content_attr1"), QStringLiteral("value1"));
QCOMPARE(attr->value("content_attr2"), QStringLiteral("value2"));
}