keepassxc

1
/*
2
 *  Copyright (C) 2024 KeePassXC Team <team@keepassxc.org>
3
 *
4
 *  This program is free software: you can redistribute it and/or modify
5
 *  it under the terms of the GNU General Public License as published by
6
 *  the Free Software Foundation, either version 2 or (at your option)
7
 *  version 3 of the License.
8
 *
9
 *  This program is distributed in the hope that it will be useful,
10
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 *  GNU General Public License for more details.
13
 *
14
 *  You should have received a copy of the GNU General Public License
15
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
16
 */
17

18
#include "TestTools.h"
19

20
#include "core/Clock.h"
21

22
#include <QRegularExpression>
23
#include <QTest>
24
#include <QUuid>
25

26
QTEST_GUILESS_MAIN(TestTools)
27

28
namespace
29
{
30
    QString createDecimal(QString wholes, QString fractions, QString unit)
31
    {
32
        return wholes + QLocale().decimalPoint() + fractions + " " + unit;
33
    }
34
} // namespace
35

36
void TestTools::testHumanReadableFileSize()
37
{
38
    constexpr auto kibibyte = 1024u;
39
    using namespace Tools;
40

41
    QCOMPARE(QString("1 B"), humanReadableFileSize(1));
42
    QCOMPARE(createDecimal("1", "00", "KiB"), humanReadableFileSize(kibibyte));
43
    QCOMPARE(createDecimal("1", "00", "MiB"), humanReadableFileSize(kibibyte * kibibyte));
44
    QCOMPARE(createDecimal("1", "00", "GiB"), humanReadableFileSize(kibibyte * kibibyte * kibibyte));
45

46
    QCOMPARE(QString("100 B"), humanReadableFileSize(100, 0));
47
    QCOMPARE(createDecimal("1", "10", "KiB"), humanReadableFileSize(kibibyte + 100));
48
    QCOMPARE(createDecimal("1", "001", "KiB"), humanReadableFileSize(kibibyte + 1, 3));
49
    QCOMPARE(createDecimal("15", "00", "KiB"), humanReadableFileSize(kibibyte * 15));
50
}
51

52
void TestTools::testIsHex()
53
{
54
    QVERIFY(Tools::isHex("0123456789abcdefABCDEF"));
55
    QVERIFY(!Tools::isHex(QByteArray("0xnothex")));
56
}
57

58
void TestTools::testIsBase64()
59
{
60
    QVERIFY(Tools::isBase64(QByteArray("1234")));
61
    QVERIFY(Tools::isBase64(QByteArray("123=")));
62
    QVERIFY(Tools::isBase64(QByteArray("12==")));
63
    QVERIFY(Tools::isBase64(QByteArray("abcd9876MN==")));
64
    QVERIFY(Tools::isBase64(QByteArray("abcd9876DEFGhijkMNO=")));
65
    QVERIFY(Tools::isBase64(QByteArray("abcd987/DEFGh+jk/NO=")));
66
    QVERIFY(!Tools::isBase64(QByteArray("abcd123==")));
67
    QVERIFY(!Tools::isBase64(QByteArray("abc_")));
68
    QVERIFY(!Tools::isBase64(QByteArray("123")));
69
}
70

71
void TestTools::testIsAsciiString()
72
{
73
    QVERIFY(Tools::isAsciiString("abcd9876DEFGhijkMNO"));
74
    QVERIFY(Tools::isAsciiString("-!&5a?`~"));
75
    QVERIFY(!Tools::isAsciiString("Štest"));
76
    QVERIFY(!Tools::isAsciiString("Ãß"));
77
}
78

79
void TestTools::testEnvSubstitute()
80
{
81
    QProcessEnvironment environment;
82

83
#if defined(Q_OS_WIN)
84
    environment.insert("HOMEDRIVE", "C:");
85
    environment.insert("HOMEPATH", "\\Users\\User");
86
    environment.insert("USERPROFILE", "C:\\Users\\User");
87

88
    QCOMPARE(Tools::envSubstitute("%HOMEDRIVE%%HOMEPATH%\\.ssh\\id_rsa", environment),
89
             QString("C:\\Users\\User\\.ssh\\id_rsa"));
90
    QCOMPARE(Tools::envSubstitute("start%EMPTY%%EMPTY%%%HOMEDRIVE%%end", environment), QString("start%C:%end"));
91
    QCOMPARE(Tools::envSubstitute("%USERPROFILE%\\.ssh\\id_rsa", environment),
92
             QString("C:\\Users\\User\\.ssh\\id_rsa"));
93
    QCOMPARE(Tools::envSubstitute("~\\.ssh\\id_rsa", environment), QString("C:\\Users\\User\\.ssh\\id_rsa"));
94
#else
95
    environment.insert("HOME", QString("/home/user"));
96
    environment.insert("USER", QString("user"));
97

98
    QCOMPARE(Tools::envSubstitute("~/.ssh/id_rsa", environment), QString("/home/user/.ssh/id_rsa"));
99
    QCOMPARE(Tools::envSubstitute("$HOME/.ssh/id_rsa", environment), QString("/home/user/.ssh/id_rsa"));
100
    QCOMPARE(Tools::envSubstitute("start/$EMPTY$$EMPTY$HOME/end", environment), QString("start/$/home/user/end"));
101
#endif
102
}
103

104
void TestTools::testValidUuid()
105
{
106
    auto validUuid = Tools::uuidToHex(QUuid::createUuid());
107
    auto nonRfc4122Uuid = "1234567890abcdef1234567890abcdef";
108
    auto emptyUuid = QString();
109
    auto shortUuid = validUuid.left(10);
110
    auto longUuid = validUuid + "baddata";
111
    auto nonHexUuid = Tools::uuidToHex(QUuid::createUuid()).replace(0, 1, 'p');
112

113
    QVERIFY(Tools::isValidUuid(validUuid));
114
    /* Before https://github.com/keepassxreboot/keepassxc/pull/1770/, entry
115
     * UUIDs are simply random 16-byte strings. Such older entries should be
116
     * accepted as well. */
117
    QVERIFY(Tools::isValidUuid(nonRfc4122Uuid));
118
    QVERIFY(!Tools::isValidUuid(emptyUuid));
119
    QVERIFY(!Tools::isValidUuid(shortUuid));
120
    QVERIFY(!Tools::isValidUuid(longUuid));
121
    QVERIFY(!Tools::isValidUuid(nonHexUuid));
122
}
123

124
void TestTools::testBackupFilePatternSubstitution_data()
125
{
126
    QTest::addColumn<QString>("pattern");
127
    QTest::addColumn<QString>("dbFilePath");
128
    QTest::addColumn<QString>("expectedSubstitution");
129

130
    static const auto DEFAULT_DB_FILE_NAME = QStringLiteral("KeePassXC");
131
    static const auto DEFAULT_DB_FILE_PATH = QStringLiteral("/tmp/") + DEFAULT_DB_FILE_NAME + QStringLiteral(".kdbx");
132
    static const auto NOW = Clock::currentDateTime();
133
    auto DEFAULT_FORMATTED_TIME = NOW.toString("dd_MM_yyyy_hh-mm-ss");
134

135
    QTest::newRow("Null pattern") << QString() << DEFAULT_DB_FILE_PATH << QString();
136
    QTest::newRow("Empty pattern") << QString("") << DEFAULT_DB_FILE_PATH << QString("");
137
    QTest::newRow("Null database path") << "valid_pattern" << QString() << QString();
138
    QTest::newRow("Empty database path") << "valid_pattern" << QString("") << QString();
139
    QTest::newRow("Unclosed/invalid pattern") << "{DB_FILENAME" << DEFAULT_DB_FILE_PATH << "{DB_FILENAME";
140
    QTest::newRow("Unknown pattern") << "{NO_MATCH}" << DEFAULT_DB_FILE_PATH << "{NO_MATCH}";
141
    QTest::newRow("Do not replace escaped patterns (filename)")
142
        << "\\{DB_FILENAME\\}" << DEFAULT_DB_FILE_PATH << "{DB_FILENAME}";
143
    QTest::newRow("Do not replace escaped patterns (time)")
144
        << "\\{TIME:dd.MM.yyyy\\}" << DEFAULT_DB_FILE_PATH << "{TIME:dd.MM.yyyy}";
145
    QTest::newRow("Multiple patterns should be replaced")
146
        << "{DB_FILENAME} {TIME} {DB_FILENAME}" << DEFAULT_DB_FILE_PATH
147
        << DEFAULT_DB_FILE_NAME + QStringLiteral(" ") + DEFAULT_FORMATTED_TIME + QStringLiteral(" ")
148
               + DEFAULT_DB_FILE_NAME;
149
    QTest::newRow("Default time pattern") << "{TIME}" << DEFAULT_DB_FILE_PATH << DEFAULT_FORMATTED_TIME;
150
    QTest::newRow("Default time pattern (empty formatter)")
151
        << "{TIME:}" << DEFAULT_DB_FILE_PATH << DEFAULT_FORMATTED_TIME;
152
    QTest::newRow("Custom time pattern") << "{TIME:dd-ss}" << DEFAULT_DB_FILE_PATH << NOW.toString("dd-ss");
153
    QTest::newRow("Invalid custom time pattern") << "{TIME:dd/-ss}" << DEFAULT_DB_FILE_PATH << NOW.toString("dd/-ss");
154
    QTest::newRow("Recursive substitution") << "{TIME:'{TIME}'}" << DEFAULT_DB_FILE_PATH << DEFAULT_FORMATTED_TIME;
155
    QTest::newRow("{DB_FILENAME} substitution")
156
        << "some {DB_FILENAME} thing" << DEFAULT_DB_FILE_PATH
157
        << QStringLiteral("some ") + DEFAULT_DB_FILE_NAME + QStringLiteral(" thing");
158
    QTest::newRow("{DB_FILENAME} substitution with multiple extensions") << "some {DB_FILENAME} thing"
159
                                                                         << "/tmp/KeePassXC.kdbx.ext"
160
                                                                         << "some KeePassXC.kdbx thing";
161
    // Not relevant right now, added test anyway
162
    QTest::newRow("There should be no substitution loops") << "{DB_FILENAME}"
163
                                                           << "{TIME:'{DB_FILENAME}'}.ext"
164
                                                           << "{DB_FILENAME}";
165
}
166

167
void TestTools::testBackupFilePatternSubstitution()
168
{
169
    QFETCH(QString, pattern);
170
    QFETCH(QString, dbFilePath);
171
    QFETCH(QString, expectedSubstitution);
172

173
    QCOMPARE(Tools::substituteBackupFilePath(pattern, dbFilePath), expectedSubstitution);
174
}
175

176
void TestTools::testEscapeRegex_data()
177
{
178
    QTest::addColumn<QString>("input");
179
    QTest::addColumn<QString>("expected");
180

181
    QString all_regular_characters = "0123456789";
182
    for (char c = 'a'; c != 'z'; ++c) {
183
        all_regular_characters += QChar::fromLatin1(c);
184
    }
185
    for (char c = 'A'; c != 'Z'; ++c) {
186
        all_regular_characters += QChar::fromLatin1(c);
187
    }
188

189
    QTest::newRow("Regular characters should not be escaped") << all_regular_characters << all_regular_characters;
190
    QTest::newRow("Special characters should be escaped") << R"(.^$*+-?()[]{}|\)"
191
                                                          << R"(\.\^\$\*\+\-\?\(\)\[\]\{\}\|\\)";
192
    QTest::newRow("Null character") << QString::fromLatin1("ab\0c", 4) << "ab\\0c";
193
}
194

195
void TestTools::testEscapeRegex()
196
{
197
    QFETCH(QString, input);
198
    QFETCH(QString, expected);
199

200
    auto actual = Tools::escapeRegex(input);
201
    QCOMPARE(actual, expected);
202
}
203

204
void TestTools::testConvertToRegex()
205
{
206
    QFETCH(QString, input);
207
    QFETCH(int, options);
208
    QFETCH(QString, expected);
209

210
    auto regex = Tools::convertToRegex(input, options).pattern();
211
    QCOMPARE(regex, expected);
212
}
213

214
void TestTools::testConvertToRegex_data()
215
{
216
    const QString input = R"(te|st*t?[5]^(test);',.)";
217

218
    QTest::addColumn<QString>("input");
219
    QTest::addColumn<int>("options");
220
    QTest::addColumn<QString>("expected");
221

222
    QTest::newRow("No Options") << input << static_cast<int>(Tools::RegexConvertOpts::DEFAULT)
223
                                << QString(R"(te|st*t?[5]^(test);',.)");
224
    // Escape regex
225
    QTest::newRow("Escape Regex") << input << static_cast<int>(Tools::RegexConvertOpts::ESCAPE_REGEX)
226
                                  << Tools::escapeRegex(input);
227
    QTest::newRow("Escape Regex and exact match")
228
        << input << static_cast<int>(Tools::RegexConvertOpts::ESCAPE_REGEX | Tools::RegexConvertOpts::EXACT_MATCH)
229
        << "^(?:" + Tools::escapeRegex(input) + ")$";
230

231
    // Exact match does not escape the pattern
232
    QTest::newRow("Exact Match") << input << static_cast<int>(Tools::RegexConvertOpts::EXACT_MATCH)
233
                                 << QString(R"(^(?:te|st*t?[5]^(test);',.)$)");
234

235
    // Exact match with improper regex
236
    QTest::newRow("Exact Match") << ")av(" << static_cast<int>(Tools::RegexConvertOpts::EXACT_MATCH)
237
                                 << QString(R"(^(?:)av()$)");
238

239
    QTest::newRow("Exact Match & Wildcard")
240
        << input << static_cast<int>(Tools::RegexConvertOpts::EXACT_MATCH | Tools::RegexConvertOpts::WILDCARD_ALL)
241
        << QString(R"(^(?:te|st.*t.\[5\]\^\(test\)\;\'\,\.)$)");
242
    QTest::newRow("Wildcard Single Match") << input << static_cast<int>(Tools::RegexConvertOpts::WILDCARD_SINGLE_MATCH)
243
                                           << QString(R"(te\|st\*t.\[5\]\^\(test\)\;\'\,\.)");
244
    QTest::newRow("Wildcard OR") << input << static_cast<int>(Tools::RegexConvertOpts::WILDCARD_LOGICAL_OR)
245
                                 << QString(R"(te|st\*t\?\[5\]\^\(test\)\;\'\,\.)");
246
    QTest::newRow("Wildcard Unlimited Match")
247
        << input << static_cast<int>(Tools::RegexConvertOpts::WILDCARD_UNLIMITED_MATCH)
248
        << QString(R"(te\|st.*t\?\[5\]\^\(test\)\;\'\,\.)");
249
}
250

251
void TestTools::testArrayContainsValues()
252
{
253
    const auto values = QStringList() << "first"
254
                                      << "second"
255
                                      << "third";
256

257
    // One missing
258
    const auto result1 = Tools::getMissingValuesFromList<QString>(values,
259
                                                                  QStringList() << "first"
260
                                                                                << "second"
261
                                                                                << "none");
262
    QCOMPARE(result1.length(), 1);
263
    QCOMPARE(result1.first(), QString("none"));
264

265
    // All found
266
    const auto result2 = Tools::getMissingValuesFromList<QString>(values,
267
                                                                  QStringList() << "first"
268
                                                                                << "second"
269
                                                                                << "third");
270
    QCOMPARE(result2.length(), 0);
271

272
    // None are found
273
    const auto numberValues = QList<int>({1, 2, 3, 4, 5});
274
    const auto result3 = Tools::getMissingValuesFromList<int>(numberValues, QList<int>({6, 7, 8}));
275
    QCOMPARE(result3.length(), 3);
276
}
277