keepassxc

1
/*
2
 *  Copyright (C) 2017 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 "TestBase32.h"
19
#include "core/Base32.h"
20

21
#include <QTest>
22

23
QTEST_GUILESS_MAIN(TestBase32)
24

25
void TestBase32::testDecode()
26
{
27
    // 3 quanta, all upper case + padding
28
    QByteArray encodedData = "JBSWY3DPEB3W64TMMQXC4LQ=";
29
    QVariant data = Base32::decode(encodedData);
30
    QString expectedData = "Hello world...";
31
    QVERIFY(!data.isNull());
32
    QCOMPARE(data.toString(), expectedData);
33
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
34

35
    // 4 quanta, all upper case
36
    encodedData = "GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ";
37
    data = Base32::decode(encodedData);
38
    expectedData = "12345678901234567890";
39
    QVERIFY(!data.isNull());
40
    QCOMPARE(data.toString(), expectedData);
41
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
42

43
    // 4 quanta, all lower case
44
    encodedData = "gezdgnbvgy3tqojqgezdgnbvgy3tqojq";
45
    data = Base32::decode(encodedData);
46
    expectedData = "12345678901234567890";
47
    QVERIFY(!data.isNull());
48
    QCOMPARE(data.toString(), expectedData);
49
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
50

51
    // 4 quanta, mixed upper and lower case
52
    encodedData = "Gezdgnbvgy3tQojqgezdGnbvgy3tQojQ";
53
    data = Base32::decode(encodedData);
54
    expectedData = "12345678901234567890";
55
    QVERIFY(!data.isNull());
56
    QCOMPARE(data.toString(), expectedData);
57
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
58

59
    // 1 pad characters
60
    encodedData = "ORSXG5A=";
61
    data = Base32::decode(encodedData);
62
    expectedData = "test";
63
    QVERIFY(!data.isNull());
64
    QCOMPARE(data.toString(), expectedData);
65
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
66

67
    // 3 pad characters
68
    encodedData = "L5PV6===";
69
    data = Base32::decode(encodedData);
70
    expectedData = "___";
71
    QVERIFY(!data.isNull());
72
    QCOMPARE(data.toString(), expectedData);
73
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
74

75
    // 4 pad characters
76
    encodedData = "MZXW6IDCMFZA====";
77
    data = Base32::decode(encodedData);
78
    expectedData = "foo bar";
79
    QVERIFY(!data.isNull());
80
    QCOMPARE(data.toString(), expectedData);
81
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
82

83
    // six pad characters
84
    encodedData = "MZXW6YTBOI======";
85
    data = Base32::decode(encodedData);
86
    expectedData = "foobar";
87
    QVERIFY(!data.isNull());
88
    QCOMPARE(data.toString(), expectedData);
89
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
90

91
    encodedData = "IA======";
92
    data = Base32::decode(encodedData);
93
    expectedData = "@";
94
    QVERIFY(!data.isNull());
95
    QCOMPARE(data.toString(), expectedData);
96
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
97

98
    // error: illegal character
99
    encodedData = "1MZXW6YTBOI=====";
100
    data = Base32::decode(encodedData);
101
    QVERIFY(data.isNull());
102

103
    // error: missing pad character
104
    encodedData = "MZXW6YTBOI=====";
105
    data = Base32::decode(encodedData);
106
    QVERIFY(data.isNull());
107

108
    // RFC 4648 test vectors
109
    encodedData = "";
110
    data = Base32::decode(encodedData);
111
    expectedData = "";
112
    QVERIFY(!data.isNull());
113
    QCOMPARE(data.toString(), expectedData);
114
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
115

116
    encodedData = "MY======";
117
    data = Base32::decode(encodedData);
118
    expectedData = "f";
119
    QVERIFY(!data.isNull());
120
    QCOMPARE(data.toString(), expectedData);
121
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
122

123
    encodedData = "MZXQ====";
124
    data = Base32::decode(encodedData);
125
    expectedData = "fo";
126
    QVERIFY(!data.isNull());
127
    QCOMPARE(data.toString(), expectedData);
128
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
129

130
    encodedData = "MZXW6===";
131
    data = Base32::decode(encodedData);
132
    QVERIFY(!data.isNull());
133
    expectedData = "foo";
134
    QCOMPARE(data.toString(), expectedData);
135
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
136

137
    encodedData = "MZXW6YQ=";
138
    data = Base32::decode(encodedData);
139
    expectedData = "foob";
140
    QVERIFY(!data.isNull());
141
    QCOMPARE(data.toString(), expectedData);
142
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
143

144
    encodedData = "MZXW6YTB";
145
    expectedData = "fooba";
146
    data = Base32::decode(encodedData);
147
    QVERIFY(!data.isNull());
148
    QCOMPARE(data.toString(), expectedData);
149
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
150

151
    encodedData = "MZXW6YTBOI======";
152
    data = Base32::decode(encodedData);
153
    expectedData = "foobar";
154
    QVERIFY(!data.isNull());
155
    QCOMPARE(data.toString(), expectedData);
156
    QVERIFY(data.value<QByteArray>().size() == expectedData.size());
157
}
158

159
void TestBase32::testEncode()
160
{
161
    QByteArray data = "Hello world...";
162
    QByteArray encodedData = Base32::encode(data);
163
    QCOMPARE(encodedData, QByteArray("JBSWY3DPEB3W64TMMQXC4LQ="));
164

165
    data = "12345678901234567890";
166
    encodedData = Base32::encode(data);
167
    QCOMPARE(encodedData, QByteArray("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"));
168

169
    data = "012345678901234567890";
170
    encodedData = Base32::encode(data);
171
    QCOMPARE(encodedData, QByteArray("GAYTEMZUGU3DOOBZGAYTEMZUGU3DOOBZGA======"));
172

173
    data = "test";
174
    encodedData = Base32::encode(data);
175
    QCOMPARE(encodedData, QByteArray("ORSXG5A="));
176

177
    data = "___";
178
    encodedData = Base32::encode(data);
179
    QCOMPARE(encodedData, QByteArray("L5PV6==="));
180

181
    data = "foo bar";
182
    encodedData = Base32::encode(data);
183
    QCOMPARE(encodedData, QByteArray("MZXW6IDCMFZA===="));
184

185
    data = "@";
186
    encodedData = Base32::encode(data);
187
    QCOMPARE(encodedData, QByteArray("IA======"));
188

189
    // RFC 4648 test vectors
190
    data = "";
191
    encodedData = Base32::encode(data);
192
    QCOMPARE(encodedData, QByteArray(""));
193

194
    data = "f";
195
    encodedData = Base32::encode(data);
196
    QCOMPARE(encodedData, QByteArray("MY======"));
197

198
    data = "fo";
199
    encodedData = Base32::encode(data);
200
    QCOMPARE(encodedData, QByteArray("MZXQ===="));
201

202
    data = "foo";
203
    encodedData = Base32::encode(data);
204
    QCOMPARE(encodedData, QByteArray("MZXW6==="));
205

206
    data = "foob";
207
    encodedData = Base32::encode(data);
208
    QCOMPARE(encodedData, QByteArray("MZXW6YQ="));
209

210
    data = "fooba";
211
    encodedData = Base32::encode(data);
212
    QCOMPARE(encodedData, QByteArray("MZXW6YTB"));
213

214
    data = "foobar";
215
    encodedData = Base32::encode(data);
216
    QCOMPARE(encodedData, QByteArray("MZXW6YTBOI======"));
217
}
218

219
void TestBase32::testAddPadding()
220
{
221
    // Empty. Invalid, returns input.
222
    QByteArray data = "";
223
    QByteArray paddedData = Base32::addPadding(data);
224
    QCOMPARE(paddedData, data);
225

226
    // One byte of encoded data. Invalid, returns input.
227
    data = "B";
228
    paddedData = Base32::addPadding(data);
229
    QCOMPARE(paddedData, data);
230

231
    // Two bytes of encoded data.
232
    data = "BB";
233
    paddedData = Base32::addPadding(data);
234
    QCOMPARE(paddedData, QByteArray("BB======"));
235

236
    // Three bytes of encoded data. Invalid, returns input.
237
    data = "BBB";
238
    paddedData = Base32::addPadding(data);
239
    QCOMPARE(paddedData, data);
240

241
    // Four bytes of encoded data.
242
    data = "BBBB";
243
    paddedData = Base32::addPadding(data);
244
    QCOMPARE(paddedData, QByteArray("BBBB===="));
245

246
    // Five bytes of encoded data.
247
    data = "BBBBB";
248
    paddedData = Base32::addPadding(data);
249
    QCOMPARE(paddedData, QByteArray("BBBBB==="));
250

251
    // Six bytes of encoded data. Invalid, returns input.
252
    data = "BBBBBB";
253
    paddedData = Base32::addPadding(data);
254
    QCOMPARE(paddedData, data);
255

256
    // Seven bytes of encoded data.
257
    data = "BBBBBBB";
258
    paddedData = Base32::addPadding(data);
259
    QCOMPARE(paddedData, QByteArray("BBBBBBB="));
260

261
    // Eight bytes of encoded data. Valid, but returns same as input.
262
    data = "BBBBBBBB";
263
    paddedData = Base32::addPadding(data);
264
    QCOMPARE(paddedData, data);
265

266
    // More than eight bytes (8+5).
267
    data = "AAAAAAAABBBBB";
268
    paddedData = Base32::addPadding(data);
269
    QCOMPARE(paddedData, QByteArray("AAAAAAAABBBBB==="));
270
}
271

272
void TestBase32::testRemovePadding()
273
{
274
    QByteArray data = "";
275
    QByteArray unpaddedData = Base32::removePadding(data);
276
    QCOMPARE(unpaddedData, data);
277

278
    data = "AAAAAAAABB======";
279
    unpaddedData = Base32::removePadding(data);
280
    QCOMPARE(unpaddedData, QByteArray("AAAAAAAABB"));
281

282
    data = "BBBB====";
283
    unpaddedData = Base32::removePadding(data);
284
    QCOMPARE(unpaddedData, QByteArray("BBBB"));
285

286
    data = "AAAAAAAABBBBB===";
287
    unpaddedData = Base32::removePadding(data);
288
    QCOMPARE(unpaddedData, QByteArray("AAAAAAAABBBBB"));
289

290
    data = "BBBBBBB=";
291
    unpaddedData = Base32::removePadding(data);
292
    QCOMPARE(unpaddedData, QByteArray("BBBBBBB"));
293

294
    // Invalid: 7 bytes of data. Returns same as input.
295
    data = "IIIIIII";
296
    unpaddedData = Base32::removePadding(data);
297
    QCOMPARE(unpaddedData, data);
298

299
    // Invalid: more padding than necessary. Returns same as input.
300
    data = "AAAAAAAABBBB=====";
301
    unpaddedData = Base32::removePadding(data);
302
    QCOMPARE(unpaddedData, data);
303
}
304

305
void TestBase32::testSanitizeInput()
306
{
307
    // sanitize input (white space + missing padding)
308
    QByteArray encodedData = "JBSW Y3DP EB3W 64TM MQXC 4LQA";
309
    auto data = Base32::decode(Base32::sanitizeInput(encodedData));
310
    QVERIFY(!data.isNull());
311
    QCOMPARE(data.toString(), QString("Hello world..."));
312

313
    // sanitize input (typo + missing padding)
314
    encodedData = "J8SWY3DPE83W64TMMQXC4LQA";
315
    data = Base32::decode(Base32::sanitizeInput(encodedData));
316
    QVERIFY(!data.isNull());
317
    QCOMPARE(data.toString(), QString("Hello world..."));
318

319
    // sanitize input (other illegal characters)
320
    encodedData = "J8SWY3D[PE83W64TMMQ]XC!4LQA";
321
    data = Base32::decode(Base32::sanitizeInput(encodedData));
322
    QVERIFY(!data.isNull());
323
    QCOMPARE(data.toString(), QString("Hello world..."));
324

325
    // sanitize input (NUL character)
326
    encodedData = "J8SWY3DPE83W64TMMQXC4LQA";
327
    encodedData.insert(3, '\0');
328
    data = Base32::decode(Base32::sanitizeInput(encodedData));
329
    QVERIFY(!data.isNull());
330
    QCOMPARE(data.toString(), QString("Hello world..."));
331
}
332