quorum: Inline quorum_aio_cb()
[qemu.git] / tests / test-crypto-block.c
1 /*
2 * QEMU Crypto block encryption
3 *
4 * Copyright (c) 2016 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "qemu/osdep.h"
22 #include "qapi/error.h"
23 #include "crypto/init.h"
24 #include "crypto/block.h"
25 #include "qemu/buffer.h"
26 #include "crypto/secret.h"
27 #ifndef _WIN32
28 #include <sys/resource.h>
29 #endif
30
31 #if (defined(_WIN32) || defined RUSAGE_THREAD)
32 #define TEST_LUKS
33 #else
34 #undef TEST_LUKS
35 #endif
36
37 static QCryptoBlockCreateOptions qcow_create_opts = {
38 .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
39 .u.qcow = {
40 .has_key_secret = true,
41 .key_secret = (char *)"sec0",
42 },
43 };
44
45 static QCryptoBlockOpenOptions qcow_open_opts = {
46 .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
47 .u.qcow = {
48 .has_key_secret = true,
49 .key_secret = (char *)"sec0",
50 },
51 };
52
53
54 #ifdef TEST_LUKS
55 static QCryptoBlockOpenOptions luks_open_opts = {
56 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
57 .u.luks = {
58 .has_key_secret = true,
59 .key_secret = (char *)"sec0",
60 },
61 };
62
63
64 /* Creation with all default values */
65 static QCryptoBlockCreateOptions luks_create_opts_default = {
66 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
67 .u.luks = {
68 .has_key_secret = true,
69 .key_secret = (char *)"sec0",
70 },
71 };
72
73
74 /* ...and with explicit values */
75 static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = {
76 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
77 .u.luks = {
78 .has_key_secret = true,
79 .key_secret = (char *)"sec0",
80 .has_cipher_alg = true,
81 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
82 .has_cipher_mode = true,
83 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
84 .has_ivgen_alg = true,
85 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
86 },
87 };
88
89
90 static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_essiv = {
91 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
92 .u.luks = {
93 .has_key_secret = true,
94 .key_secret = (char *)"sec0",
95 .has_cipher_alg = true,
96 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
97 .has_cipher_mode = true,
98 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
99 .has_ivgen_alg = true,
100 .ivgen_alg = QCRYPTO_IVGEN_ALG_ESSIV,
101 .has_ivgen_hash_alg = true,
102 .ivgen_hash_alg = QCRYPTO_HASH_ALG_SHA256,
103 .has_hash_alg = true,
104 .hash_alg = QCRYPTO_HASH_ALG_SHA1,
105 },
106 };
107 #endif /* TEST_LUKS */
108
109
110 static struct QCryptoBlockTestData {
111 const char *path;
112 QCryptoBlockCreateOptions *create_opts;
113 QCryptoBlockOpenOptions *open_opts;
114
115 bool expect_header;
116
117 QCryptoCipherAlgorithm cipher_alg;
118 QCryptoCipherMode cipher_mode;
119 QCryptoHashAlgorithm hash_alg;
120
121 QCryptoIVGenAlgorithm ivgen_alg;
122 QCryptoHashAlgorithm ivgen_hash;
123
124 bool slow;
125 } test_data[] = {
126 {
127 .path = "/crypto/block/qcow",
128 .create_opts = &qcow_create_opts,
129 .open_opts = &qcow_open_opts,
130
131 .expect_header = false,
132
133 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_128,
134 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
135
136 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
137 },
138 #ifdef TEST_LUKS
139 {
140 .path = "/crypto/block/luks/default",
141 .create_opts = &luks_create_opts_default,
142 .open_opts = &luks_open_opts,
143
144 .expect_header = true,
145
146 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
147 .cipher_mode = QCRYPTO_CIPHER_MODE_XTS,
148 .hash_alg = QCRYPTO_HASH_ALG_SHA256,
149
150 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
151
152 .slow = true,
153 },
154 {
155 .path = "/crypto/block/luks/aes-256-cbc-plain64",
156 .create_opts = &luks_create_opts_aes256_cbc_plain64,
157 .open_opts = &luks_open_opts,
158
159 .expect_header = true,
160
161 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
162 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
163 .hash_alg = QCRYPTO_HASH_ALG_SHA256,
164
165 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
166
167 .slow = true,
168 },
169 {
170 .path = "/crypto/block/luks/aes-256-cbc-essiv",
171 .create_opts = &luks_create_opts_aes256_cbc_essiv,
172 .open_opts = &luks_open_opts,
173
174 .expect_header = true,
175
176 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
177 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
178 .hash_alg = QCRYPTO_HASH_ALG_SHA1,
179
180 .ivgen_alg = QCRYPTO_IVGEN_ALG_ESSIV,
181 .ivgen_hash = QCRYPTO_HASH_ALG_SHA256,
182
183 .slow = true,
184 },
185 #endif
186 };
187
188
189 static ssize_t test_block_read_func(QCryptoBlock *block,
190 size_t offset,
191 uint8_t *buf,
192 size_t buflen,
193 Error **errp,
194 void *opaque)
195 {
196 Buffer *header = opaque;
197
198 g_assert_cmpint(offset + buflen, <=, header->capacity);
199
200 memcpy(buf, header->buffer + offset, buflen);
201
202 return buflen;
203 }
204
205
206 static ssize_t test_block_init_func(QCryptoBlock *block,
207 size_t headerlen,
208 Error **errp,
209 void *opaque)
210 {
211 Buffer *header = opaque;
212
213 g_assert_cmpint(header->capacity, ==, 0);
214
215 buffer_reserve(header, headerlen);
216
217 return headerlen;
218 }
219
220
221 static ssize_t test_block_write_func(QCryptoBlock *block,
222 size_t offset,
223 const uint8_t *buf,
224 size_t buflen,
225 Error **errp,
226 void *opaque)
227 {
228 Buffer *header = opaque;
229
230 g_assert_cmpint(buflen + offset, <=, header->capacity);
231
232 memcpy(header->buffer + offset, buf, buflen);
233 header->offset = offset + buflen;
234
235 return buflen;
236 }
237
238
239 static Object *test_block_secret(void)
240 {
241 return object_new_with_props(
242 TYPE_QCRYPTO_SECRET,
243 object_get_objects_root(),
244 "sec0",
245 &error_abort,
246 "data", "123456",
247 NULL);
248 }
249
250 static void test_block_assert_setup(const struct QCryptoBlockTestData *data,
251 QCryptoBlock *blk)
252 {
253 QCryptoIVGen *ivgen;
254 QCryptoCipher *cipher;
255
256 ivgen = qcrypto_block_get_ivgen(blk);
257 cipher = qcrypto_block_get_cipher(blk);
258
259 g_assert(ivgen);
260 g_assert(cipher);
261
262 g_assert_cmpint(data->cipher_alg, ==, cipher->alg);
263 g_assert_cmpint(data->cipher_mode, ==, cipher->mode);
264 g_assert_cmpint(data->hash_alg, ==,
265 qcrypto_block_get_kdf_hash(blk));
266
267 g_assert_cmpint(data->ivgen_alg, ==,
268 qcrypto_ivgen_get_algorithm(ivgen));
269 g_assert_cmpint(data->ivgen_hash, ==,
270 qcrypto_ivgen_get_hash(ivgen));
271 }
272
273
274 static void test_block(gconstpointer opaque)
275 {
276 const struct QCryptoBlockTestData *data = opaque;
277 QCryptoBlock *blk;
278 Buffer header;
279 Object *sec = test_block_secret();
280
281 memset(&header, 0, sizeof(header));
282 buffer_init(&header, "header");
283
284 blk = qcrypto_block_create(data->create_opts,
285 test_block_init_func,
286 test_block_write_func,
287 &header,
288 &error_abort);
289 g_assert(blk);
290
291 if (data->expect_header) {
292 g_assert_cmpint(header.capacity, >, 0);
293 } else {
294 g_assert_cmpint(header.capacity, ==, 0);
295 }
296
297 test_block_assert_setup(data, blk);
298
299 qcrypto_block_free(blk);
300 object_unparent(sec);
301
302 /* Ensure we can't open without the secret */
303 blk = qcrypto_block_open(data->open_opts,
304 test_block_read_func,
305 &header,
306 0,
307 NULL);
308 g_assert(blk == NULL);
309
310 /* Ensure we can't open without the secret, unless NO_IO */
311 blk = qcrypto_block_open(data->open_opts,
312 test_block_read_func,
313 &header,
314 QCRYPTO_BLOCK_OPEN_NO_IO,
315 &error_abort);
316
317 g_assert(qcrypto_block_get_cipher(blk) == NULL);
318 g_assert(qcrypto_block_get_ivgen(blk) == NULL);
319
320 qcrypto_block_free(blk);
321
322
323 /* Now open for real with secret */
324 sec = test_block_secret();
325 blk = qcrypto_block_open(data->open_opts,
326 test_block_read_func,
327 &header,
328 0,
329 &error_abort);
330 g_assert(blk);
331
332 test_block_assert_setup(data, blk);
333
334 qcrypto_block_free(blk);
335
336 object_unparent(sec);
337
338 buffer_free(&header);
339 }
340
341
342 int main(int argc, char **argv)
343 {
344 gsize i;
345
346 module_call_init(MODULE_INIT_QOM);
347 g_test_init(&argc, &argv, NULL);
348
349 g_assert(qcrypto_init(NULL) == 0);
350
351 for (i = 0; i < G_N_ELEMENTS(test_data); i++) {
352 if (test_data[i].open_opts->format == Q_CRYPTO_BLOCK_FORMAT_LUKS &&
353 !qcrypto_hash_supports(test_data[i].hash_alg)) {
354 continue;
355 }
356 if (!test_data[i].slow ||
357 g_test_slow()) {
358 g_test_add_data_func(test_data[i].path, &test_data[i], test_block);
359 }
360 }
361
362 return g_test_run();
363 }